﻿define(['jquery', 'bootstrap', 'backend', 'table', 'form'], function ($, undefined, Backend, Table, Form) {

    // 检查密码对话框函数是否存在，如果不存在则创建简单的替代实现
    if (typeof window.showSchedulePasswordDialog === 'undefined') {
        window.showSchedulePasswordDialog = function (callback) {
            var password = prompt('请输入排课密码：');
            if (password && typeof callback === 'function') {
                callback(password);
            }
        };
    }

    if (typeof window.showCancelPasswordDialog === 'undefined') {
        window.showCancelPasswordDialog = function (callback) {
            var password = prompt('请输入取消排课密码：');
            if (password && typeof callback === 'function') {
                callback(password);
            }
        };
    }

    var Controller = {
        index: function () {
            // 初始化表格参数配置
            Table.api.init({
                extend: {
                    index_url: 'course/schedule/index' + location.search,
                    add_url: 'course/schedule/add',
                    edit_url: 'course/schedule/edit',
                    del_url: 'course/schedule/del',
                    multi_url: 'course/schedule/multi',
                    import_url: 'course/schedule/import',
                    table: 'course_schedule',
                }
            });

            var table = $("#table");

            // 初始化表格
            table.bootstrapTable({
                url: $.fn.bootstrapTable.defaults.extend.index_url,
                stickyHeader: true, // 启用粘性表头
                stickyHeaderOffsetY: 150, // 设置粘性表头Y轴偏移量，防止被顶部导航栏遮挡
                queryParams: function (params) {
                    // 禁用服务器端分页，一次性加载所有数据
                    params.limit = 999999;

                    // 添加城市和学校参数
                    var cityId = $('#c-cityarea_id').val();
                    var schoolId = $('#c-school_id').val();

                    if (cityId) {
                        params.city_id = cityId;
                    }
                    if (schoolId) {
                        params.school_id = schoolId;
                    }
                    return params;
                },
                pk: 'id',
                sortName: 'id',
                sortOrder: 'desc',
                sidePagination: 'server', // 使用服务器端分页，但设置很大的limit
                pagination: true, // 启用分页但设置很大的页面大小
                pageSize: 999999, // 设置很大的值以显示所有数据
                // 添加行样式格式化
                rowStyle: function (row, index) {
                    var style = {};

                    // 如果是正式排课，设置绿色文字
                    if (typeof Config.isFormalSchedule !== 'undefined' && Config.isFormalSchedule) {
                        style.css = {
                            'color': '#28a745',
                        };
                    }

                    // 如果单条记录标记为正式排课，也设置绿色背景
                    if (row.is_formal) {
                        style.classes = 'success';
                    }

                    return style;
                },
                columns: [
                    [
                        {checkbox: true},
                        {field: 'id', title: 'ID', sortable: true, visible: false},
                        {field: 'publicwelfare_id', title: '项目ID', operate: '=', visible: false},
                        {field: 'publicwelfare_id_text', title: '项目', operate: 'LIKE'},
                        {field: 'course_text', title: '课程', operate: 'LIKE', align: 'left'},
                        {field: 'classes_id', title: '班级ID', operate: 'LIKE', align: 'left'},
                        {field: 'community_text', title: '社区', operate: 'LIKE', align: 'left'},
                        {field: 'time_zone_text', title: '时区', operate: 'LIKE', align: 'left'},
                        {field: 'time_slot_text', title: '时间', operate: 'LIKE', align: 'left'},
                        {
                            field: 'operate',
                            title: __('Operate'),
                            table: table,
                            events: Table.api.events.operate,
                            formatter: Table.api.formatter.operate,
                            buttons: [
                                {
                                    name: 'edit',
                                    title: __('Edit'),
                                    icon: 'fa fa-pencil',
                                    classname: 'btn btn-xs btn-success btn-editone btn-dialog',
                                    url: 'course/schedule/edit',
                                    extend: 'data-area=["80%","80%"] data-title="编辑课程排期"'
                                }
                            ]
                        }
                    ]
                ]
            });

            // 表格加载完成后的处理
            table.on('load-success.bs.table', function (e, data) {
                $('.btn-dragsort').remove();

                // 清空全局数组
                window.allRecords = [];
                window.expiredRecords = [];
                window.normalRecords = [];

                // 添加事件分组处理功能
                setTimeout(function () {
                    handleScheduleEventGrouping();
                }, 100);
                
                // 页面加载完成后自动选中第一个项目
                if ($('.project-list li').length > 1) {
                    // 检查是否已经选择了项目，如果没有则自动选择第一个
                    var selectedProject = $('.dropdown-toggle').text().trim();
                    if (selectedProject === '选择项目' || selectedProject === '全部项目') {
                        var firstProject = $('.project-list li:eq(1) a'); // 第一个是"全部项目"，所以选择第二个
                        if (firstProject.length > 0) {
                            firstProject.click();
                        }
                    }
                }
            });

            // 初始化全局变量
            window.allRecords = [];
            window.expiredRecords = [];
            window.normalRecords = [];
            window.currentPage = {
                expired: 1,
                normal: 1
            };
            window.pageSize = 30; // 每页显示的记录数

            // 为表格绑定事件
            var script = document.createElement('script');
            script.src = '/assets/js/backend/common/index.js';
            document.head.appendChild(script);
            Table.api.bindevent(table);

            // 强制设置父容器的overflow以确保粘性表头正常工作
            table.closest('.panel-body').css('overflow', 'visible');

            // 项目列表下拉框点击事件
            $(document).on('click', '.project-list a', function () {
                var id = $(this).data('id');
                var name = $(this).text();

                // 更新按钮文本
                $('.dropdown-toggle').html('<i class="fa fa-filter"></i> ' + name + ' <span class="caret"></span>');

                // 重新加载表格数据，带上项目ID参数
                if (id > 0) {
                    // 直接使用完整URL路径带参数
                    var url = 'course/schedule/index?publicwelfare_id=' + id;
                    table.bootstrapTable('refresh', {
                        url: Fast.api.fixurl(url)
                    });
                } else {
                    // 如果是全部项目，使用原始 URL
                    table.bootstrapTable('refresh', {
                        url: $.fn.bootstrapTable.defaults.extend.index_url
                    });
                }

                // 如果选择了具体项目，启用清空按钮
                if (id > 0) {
                    $('.btn-clear-schedule').removeClass('disabled').data('id', id);
                } else {
                    $('.btn-clear-schedule').addClass('disabled').data('id', 0);
                }
            });

            // 排课表格按钮点击事件
            $(document).on('click', '.btn-table-popup', function () {
                // 获取当前选中的项目id
                var publicwelfare_id = $('.btn-clear-schedule').data('id') || 0;
                var url = 'course/schedule/table';
                if (publicwelfare_id > 0) {
                    url += '?publicwelfare_id=' + publicwelfare_id;
                }

                // 使用Layer弹出窗口，并设置为真正的全屏
                Fast.api.open(url, '排课表格', {
                    area: ['100%', '100%'],
                    offset: ['0px', '0px'], // 设置偏移量为0，使其完全全屏
                    maxmin: true,
                    shadeClose: false,
                    shade: 0.4,
                    full: true // 默认开启全屏
                });
            });

            // 自动排课按钮点击事件
            $(document).on('click', '.btn-generate-popup', function () {
                // 获取当前选中的项目id
                var publicwelfare_id = $('.btn-clear-schedule').data('id') || 0;
                var url = 'course/schedule/generate';
                if (publicwelfare_id > 0) {
                    url += '?publicwelfare_id=' + publicwelfare_id;
                }

                // 使用Layer弹出窗口，并设置为全屏
                Fast.api.open(url, '自动排课', {
                    area: ['95%', '95%'],
                    maxmin: true,
                    shadeClose: false,
                    shade: 0.4
                });
            });

            // 清空项目排期按钮点击事件
            $(document).on('click', '.btn-clear-schedule:not(.disabled)', function () {
                var id = $(this).data('id');
                if (!id) {
                    Layer.alert('请先选择项目');
                    return;
                }

                Layer.confirm('确定要清空此项目的所有排期吗？此操作不可撤销！', {
                    btn: ['确定', '取消']
                }, function (index) {
                    Fast.api.ajax({
                        url: 'course/schedule/clear',
                        data: {publicwelfare_id: id}
                    }, function (data, ret) {
                        // 关闭确认弹窗
                        Layer.close(index);
                        // 显示成功提示2秒钟
                        Layer.msg('清空成功！', {time: 2000});
                        // 刷新表格数据
                        table.bootstrapTable('refresh');
                        return false;
                    });
                });
            });

            var currentProjectId = 0;

            // 项目选择事件
            $('.project-list a').on('click', function () {
                currentProjectId = $(this).data('id');
                checkAndToggleButtons(currentProjectId);
            });

            // 处理课程事件分组（未过期和已过期）
            function handleScheduleEventGrouping() {
                var currentDate = new Date();
                window.expiredRecords = [];
                window.normalRecords = [];
                window.allRecords = []; // 确保allRecords被清空

                // 获取当前日期字符串
                var today = new Date();
                var currentDateStr = today.getFullYear() + '-' +
                    String(today.getMonth() + 1).padStart(2, '0') + '-' +
                    String(today.getDate()).padStart(2, '0');

                var totalRows = $('#table tbody tr').length;
                var processedRows = 0;
                var expiredCount = 0;
                var normalCount = 0;
                var emptyDateCount = 0;
                var invalidDateCount = 0;

                // 遍历表格行，分组过期和未过期的事件
                $('#table tbody tr').each(function (index) {
                    var $row = $(this);
                    processedRows++;

                    // 检查行的基本信息
                    var rowId = $row.find('td').eq(1).text().trim(); // ID列
                    var dateCell = $row.find('td').eq(6); // 时间列
                    var dateText = dateCell.text().trim();

                    // 保存所有记录，无论日期如何
                    // 使用深度克隆确保保留所有事件处理程序和数据
                    var $clonedRow = $row.clone(true);
                    $clonedRow.find('*').addBack().data('events', $row.find('*').addBack().data('events'));
                    window.allRecords.push($clonedRow);

                    if (dateText && dateText !== '') {
                        // 从日期字符串中提取日期部分（格式如"2025-07-10 时间段"）
                        var dateParts = dateText.split(' ');
                        var dateOnly = dateParts[0]; // 提取日期部分，如"2025-07-10"

                        // 标准化日期格式（处理可能的单数字月份和日期）
                        var dateMatch = dateOnly.match(/(\d{4})-(\d{1,2})-(\d{1,2})/);
                        if (dateMatch) {
                            var year = dateMatch[1];
                            var month = String(parseInt(dateMatch[2])).padStart(2, '0');
                            var day = String(parseInt(dateMatch[3])).padStart(2, '0');
                            dateOnly = year + '-' + month + '-' + day;
                        }

                        // 验证标准化后的日期格式
                        var dateRegex = /^\d{4}-\d{2}-\d{2}$/;
                        if (!dateRegex.test(dateOnly)) {
                            invalidDateCount++;
                            window.normalRecords.push($row.clone(true)); // 使用克隆
                            $row.addClass('normal-original');
                            normalCount++;
                            return;
                        }

                        // 比较日期字符串（这样可以避免时区问题）
                        if (dateOnly < currentDateStr) {
                            window.expiredRecords.push($row.clone(true)); // 保存行数据的克隆
                            $row.addClass('expired-original'); // 添加标记但不隐藏，由showEventsByType控制显示
                            expiredCount++;
                        } else {
                            window.normalRecords.push($row.clone(true)); // 保存行数据的克隆
                            $row.addClass('normal-original');
                            normalCount++;
                        }
                    } else {
                        window.normalRecords.push($row.clone(true)); // 使用克隆
                        $row.addClass('normal-original');
                        emptyDateCount++;
                        normalCount++;
                    }
                });

                // 获取Bootstrap Table的原始数据
                var bootstrapTableData = $('#table').bootstrapTable('getData');
                var backendDataCount = bootstrapTableData ? bootstrapTableData.length : 0;

                // 计算分组总数
                var groupedTotal = window.expiredRecords.length + window.normalRecords.length;

                // 重置分页状态
                window.currentPage = {
                    expired: 1,
                    normal: 1,
                    all: 1
                };

                // 隐藏所有原始行，让分组显示接管
                $('#table tbody tr').hide();

                // 创建切换控制器
                createEventToggleController();

                // 确保显示事件
                if (window.currentView) {
                    showEventsByType(window.currentView);
                } else {
                    window.currentView = 'normal';
                    showEventsByType('normal');
                }
            }

            // 检查并切换按钮显示状态
            function checkAndToggleButtons(projectId) {
                if (projectId == 0) {
                    // 没有选择项目时，隐藏所有项目相关的操作按钮
                    $('.btn-clear-schedule, .btn-generate-popup, .btn-table-popup').hide();
                    $('.btn-confirm-schedule, .btn-cancel-schedule').hide();
                    return;
                }

                // 检查该项目是否已有正式排课记录
                $.ajax({
                    url: 'course/schedule/checkFormalSchedule',
                    type: 'GET',
                    data: {publicwelfare_id: projectId},
                    success: function (response) {
                        if (response.code == 1) {
                            if (response.data.has_formal) {
                                // 已有正式排课记录，隐藏清空和自动排课按钮，显示社区排课表格按钮
                                $('.btn-clear-schedule, .btn-generate-popup').hide();
                                $('.btn-table-popup').show();
                                $('.btn-confirm-schedule').hide();
                                $('.btn-cancel-schedule').show();
                            } else {
                                // 没有正式排课记录，显示所有按钮
                                $('.btn-clear-schedule, .btn-table-popup').show();
                                $('.btn-confirm-schedule').show();
                                $('.btn-cancel-schedule').hide();
                            }
                        }
                    }
                });
            }

            // 正式排课按钮点击事件
            $('.btn-confirm-schedule').on('click', function () {
                if (currentProjectId == 0) {
                    Toastr.error('请先选择要正式排课的项目');
                    return;
                }

                // 使用密码验证对话框替代简单确认
                showSchedulePasswordDialog(function (password) {
                    $.ajax({
                        url: 'course/schedule/confirmSchedule',
                        type: 'POST',
                        data: {
                            publicwelfare_id: currentProjectId,
                            password: password
                        },
                        success: function (response) {
                            $('#schedulePasswordModal').modal('hide');

                            if (response.code == 1) {
                                Toastr.success(response.msg);
                                // 刷新页面或重新检查按钮状态
                                checkAndToggleButtons(currentProjectId);
                                // 刷新表格
                                $("#table").bootstrapTable('refresh');
                            } else {
                                Toastr.error(response.msg);
                            }
                        },
                        error: function (xhr, status, error) {
                            $('#schedulePasswordModal').modal('hide');

                            try {
                                var response = JSON.parse(xhr.responseText);
                                Toastr.error(response.msg || '操作失败');
                            } catch (e) {
                                Toastr.error('请求失败，请重试');
                            }
                        }
                    });
                });
            });

            // 取消正式排课按钮点击事件
            $('.btn-cancel-schedule').on('click', function () {
                if (currentProjectId == 0) {
                    Toastr.error('请先选择要取消排课的项目');
                    return;
                }

                // 检查是否有正式排课记录
                $.ajax({
                    url: 'course/schedule/checkFormalSchedule',
                    type: 'GET',
                    data: {publicwelfare_id: currentProjectId},
                    success: function (response) {
                        if (response.code == 1) {
                            if (!response.data.has_formal) {
                                Toastr.warning('该项目没有正式排课数据，无需取消');
                                return;
                            }

                            // 显示密码验证对话框
                            showCancelPasswordDialog(function (password) {
                                $.ajax({
                                    url: 'course/schedule/cancelSchedule',
                                    type: 'POST',
                                    data: {
                                        publicwelfare_id: currentProjectId,
                                        password: password
                                    },
                                    success: function (response) {
                                        $('#schedulePasswordModal').modal('hide');

                                        if (response.code == 1) {
                                            Toastr.success(response.msg);
                                            // 刷新页面或重新检查按钮状态
                                            checkAndToggleButtons(currentProjectId);
                                            // 刷新表格
                                            $("#table").bootstrapTable('refresh');
                                        } else {
                                            Toastr.error(response.msg);
                                        }
                                    },
                                    error: function (xhr, status, error) {
                                        $('#schedulePasswordModal').modal('hide');

                                        try {
                                            var response = JSON.parse(xhr.responseText);
                                            Toastr.error(response.msg || '取消排课失败');
                                        } catch (e) {
                                            Toastr.error('请求失败，请重试');
                                        }
                                    }
                                });
                            });
                        } else {
                            Toastr.error('检查排课状态失败');
                        }
                    },
                    error: function () {
                        Toastr.error('检查排课状态失败');
                    }
                });
            });

            // 页面加载时检查默认项目状态
            checkAndToggleButtons(0);

            // 创建事件切换控制器
            function createEventToggleController() {
                // 移除现有的控制器
                $('#event-toggle-controller').remove();

                // 创建切换按钮容器和分页控制器
                var controllerHtml = '<div id="event-toggle-controller" style="margin-bottom: 15px; padding: 10px; background-color: #f8f9fa; border-radius: 5px; border: 1px solid #dee2e6;">' +
                    '<div class="row">' +
                    '<div class="col-md-6">' +
                    '<div class="btn-group" role="group">' +
                    '<button type="button" class="btn btn-primary btn-sm toggle-normal active" data-type="normal">' +
                    '<i class="fa fa-calendar-check-o"></i> 未过期事件 (' + window.normalRecords.length + ')' +
                    '</button>' +
                    '<button type="button" class="btn btn-outline-secondary btn-sm toggle-expired" data-type="expired">' +
                    '<i class="fa fa-clock-o"></i> 已过期事件 (' + window.expiredRecords.length + ')' +
                    '</button>' +
                    '<button type="button" class="btn btn-outline-secondary btn-sm toggle-all" data-type="all">' +
                    '<i class="fa fa-list"></i> 全部事件 (' + window.allRecords.length + ')' +
                    '</button>' +
                    '</div>' +
                    '</div>' +
                    '<div class="col-md-6 text-right">' +
                    '<div id="pagination-info" class="d-inline-block mr-3"></div>' +
                    '<div id="pagination-controls" class="d-inline-block"></div>' +
                    '</div>' +
                    '</div>' +
                    '</div>';

                // 将控制器插入到表格前面
                $('#table').before(controllerHtml);

                // 创建底部分页控制器
                createBottomPaginationController();

                // 默认显示未过期事件
                window.currentView = 'normal';

                // 绑定切换事件
                $('.toggle-normal, .toggle-expired, .toggle-all').off('click').on('click', function () {
                    var type = $(this).data('type');

                    // 更新按钮状态
                    $('.toggle-normal, .toggle-expired, .toggle-all').removeClass('btn-primary active').addClass('btn-outline-secondary');
                    $(this).removeClass('btn-outline-secondary').addClass('btn-primary active');

                    // 切换显示内容
                    window.currentView = type;
                    showEventsByType(type);
                });

                // 如果未过期事件为0但有全部事件，自动切换到全部事件视图
                if (window.normalRecords.length === 0 && window.allRecords.length > 0) {
                    window.currentView = 'all';
                    $('.toggle-all').removeClass('btn-outline-secondary').addClass('btn-primary active');
                    $('.toggle-normal, .toggle-expired').removeClass('btn-primary active').addClass('btn-outline-secondary');
                    showEventsByType('all');
                } else {
                    // 确保初始显示正确
                    showEventsByType('normal');
                }
            }

            // 创建底部分页控制器
            function createBottomPaginationController() {
                // 移除现有的底部控制器
                $('#bottom-pagination-controller').remove();

                // 创建底部分页控制器HTML
                var bottomControllerHtml = '<div id="bottom-pagination-controller" style="margin-top: 15px; padding: 15px; background-color: #f8f9fa; border-radius: 5px; border: 1px solid #dee2e6; border-top: 2px solid #007bff;">' +
                    '<div class="row align-items-center">' +
                    '<div class="col-md-6">' +
                    '<div id="bottom-pagination-info" class="text-muted"></div>' +
                    '</div>' +
                    '<div class="col-md-6">' +
                    '<div id="bottom-pagination-controls" class="text-right"></div>' +
                    '</div>' +
                    '</div>' +
                    '</div>';

                // 将底部控制器插入到表格后面
                $('#table').after(bottomControllerHtml);
            }

            // 根据类型显示事件（带分页）
            function showEventsByType(type) {
                // 先隐藏所有原始行
                $('#table tbody tr').hide();

                // 清空当前表格内容
                $('#table tbody').empty();

                // 根据类型选择要显示的记录
                var allRows;
                if (type === 'expired') {
                    allRows = window.expiredRecords;
                } else if (type === 'normal') {
                    allRows = window.normalRecords;
                } else if (type === 'all') {
                    allRows = window.allRecords;
                }

                // 确保currentPage对象有all属性
                if (!window.currentPage.all) {
                    window.currentPage.all = 1;
                }

                var currentPage = window.currentPage[type];
                var pageSize = window.pageSize;
                if (allRows.length === 0) {
                    // 如果没有数据，显示提示信息
                    var emptyMessage;
                    var icon;
                    if (type === 'expired') {
                        emptyMessage = '暂无已过期的课程事件';
                        icon = 'clock-o';
                    } else if (type === 'normal') {
                        emptyMessage = '暂无未过期的课程事件';
                        icon = 'calendar-check-o';
                    } else {
                        emptyMessage = '暂无课程事件';
                        icon = 'calendar';
                    }

                    $('#table tbody').append(
                        '<tr><td colspan="100%" class="text-center text-muted" style="padding: 40px;">' +
                        '<i class="fa fa-' + icon + ' fa-2x"></i><br>' +
                        '<div class="mt-2">' + emptyMessage + '</div>' +
                        '</td></tr>'
                    );
                    // 隐藏分页控制器
                    $('#pagination-info').empty();
                    $('#pagination-controls').empty();
                    $('#bottom-pagination-info').empty();
                    $('#bottom-pagination-controls').empty();
                } else {
                    // 计算分页参数
                    var totalPages = Math.ceil(allRows.length / pageSize);
                    var startIndex = (currentPage - 1) * pageSize;
                    var endIndex = Math.min(startIndex + pageSize, allRows.length);
                    var rowsToShow = allRows.slice(startIndex, endIndex);

                    // 使用jQuery直接添加HTML字符串
                    var htmlRows = [];

                    rowsToShow.forEach(function ($row, index) {
                        // 确保行是jQuery对象
                        if (!($row instanceof jQuery)) {
                            return;
                        }

                        try {
                            // 克隆行并确保可见
                            var $newRow = $row.clone();
                            $newRow.css('display', '');

                            // 为过期行添加特殊样式
                            if (type === 'expired' || (type === 'all' && $row.hasClass('expired-original'))) {
                                $newRow.addClass('expired-row');
                            }

                            // 获取行的HTML并添加到数组
                            htmlRows.push($newRow.prop('outerHTML'));
                        } catch (e) {
                            // 处理错误
                        }
                    });

                    // 一次性添加所有HTML
                    if (htmlRows.length > 0) {
                        $('#table tbody').append(htmlRows.join(''));
                    }

                    // 更新分页信息
                    updatePaginationInfo(type, currentPage, totalPages, startIndex + 1, endIndex, allRows.length);

                    // 更新分页控制器
                    updatePaginationControls(type, currentPage, totalPages);
                }

                // 添加样式 - 更新时间: 2024-12-23
                if (!$('#event-grouping-styles').length) {
                    $('<style id="event-grouping-styles">' +
                        '.expired-row { background-color: #fff5f5 !important; }' +
                        '.expired-row td { border: none !important; color: #721c24; font-weight: normal !important; }' +
                        '.expired-row { border: none !important; }' +
                        '.toggle-normal.active, .toggle-expired.active { box-shadow: 0 2px 4px rgba(0,123,255,0.3); }' +
                        '#event-toggle-controller .btn { transition: all 0.2s ease; }' +
                        '#event-toggle-controller .btn:hover { transform: translateY(-1px); }' +
                        '.pagination-btn { margin: 0 2px; padding: 4px 8px; border: 1px solid #ddd; background: #fff; cursor: pointer; }' +
                        '.pagination-btn:hover { background: #f5f5f5; }' +
                        '.pagination-btn.active { background: #007bff; color: #fff; border-color: #007bff; }' +
                        '.pagination-btn:disabled { background: #f8f9fa; color: #6c757d; cursor: not-allowed; }' +
                        '</style>').appendTo('head');
                }
            }

            // 更新分页信息
            function updatePaginationInfo(type, currentPage, totalPages, startIndex, endIndex, totalRecords) {
                var typeText;
                if (type === 'expired') {
                    typeText = '已过期';
                } else if (type === 'normal') {
                    typeText = '未过期';
                } else if (type === 'all') {
                    typeText = '全部';
                }
                var infoText = '显示 ' + typeText + ' 第 ' + startIndex + '-' + endIndex + ' 条，共 ' + totalRecords + ' 条记录（第 ' + currentPage + '/' + totalPages + ' 页）';

                // 同时更新顶部和底部的分页信息
                $('#pagination-info').html('<small class="text-muted">' + infoText + '</small>');
                $('#bottom-pagination-info').html('<div class="d-flex align-items-center">' +
                    '<i class="fa fa-info-circle text-primary mr-2"></i>' +
                    '<span>' + infoText + '</span>' +
                    '</div>');
            }

            // 更新分页控制器
            function updatePaginationControls(type, currentPage, totalPages) {
                var controlsHtml = '';

                if (totalPages > 1) {
                    // 上一页按钮
                    controlsHtml += '<button class="pagination-btn" data-page="' + (currentPage - 1) + '" data-type="' + type + '"' +
                        (currentPage <= 1 ? ' disabled' : '') + '>上一页</button>';

                    // 页码按钮
                    var startPage = Math.max(1, currentPage - 2);
                    var endPage = Math.min(totalPages, currentPage + 2);

                    if (startPage > 1) {
                        controlsHtml += '<button class="pagination-btn" data-page="1" data-type="' + type + '">1</button>';
                        if (startPage > 2) {
                            controlsHtml += '<span class="pagination-ellipsis">...</span>';
                        }
                    }

                    for (var i = startPage; i <= endPage; i++) {
                        controlsHtml += '<button class="pagination-btn' + (i === currentPage ? ' active' : '') + '" data-page="' + i + '" data-type="' + type + '">' + i + '</button>';
                    }

                    if (endPage < totalPages) {
                        if (endPage < totalPages - 1) {
                            controlsHtml += '<span class="pagination-ellipsis">...</span>';
                        }
                        controlsHtml += '<button class="pagination-btn" data-page="' + totalPages + '" data-type="' + type + '">' + totalPages + '</button>';
                    }

                    // 下一页按钮
                    controlsHtml += '<button class="pagination-btn" data-page="' + (currentPage + 1) + '" data-type="' + type + '"' +
                        (currentPage >= totalPages ? ' disabled' : '') + '>下一页</button>';
                }

                // 同时更新顶部和底部的分页控制器
                $('#pagination-controls').html(controlsHtml);
                $('#bottom-pagination-controls').html(controlsHtml);

                // 绑定分页按钮事件（顶部和底部）
                $('.pagination-btn').off('click').on('click', function () {
                    if ($(this).prop('disabled')) return;

                    var page = parseInt($(this).data('page'));
                    var pageType = $(this).data('type');

                    if (page && pageType) {
                        window.currentPage[pageType] = page;
                        showEventsByType(pageType);
                    }
                });
            }

        },
        add: function () {
            var script = document.createElement('script');
            script.src = '/assets/js/backend/common/add.js?';
            document.head.appendChild(script);
            Controller.api.bindevent();
        },
        edit: function () {
            var script = document.createElement('script');
            script.src = '/assets/js/backend/common/add.js?';
            document.head.appendChild(script);
            Controller.api.bindevent();
        },
        table: function () {
            thistable = this;
            // 绑定表格筛选表单提交
            Form.api.bindevent($("form[role=form]"));

            // 添加CSS样式
            var style = $('<style>\n' +
                '.empty-row { display: none; }\n' +
                '.toggle-empty-rows { margin-bottom: 10px; }\n' +
                '.table-responsive { position: relative; overflow-x: auto; width: 100%; }\n' +
                '.table-header-fixed { position: fixed; top: 0; z-index: 100; background-color: #fff; box-shadow: 0 2px 4px rgba(0,0,0,0.1); display: none; overflow: hidden; }\n' +
                '.table-header-fixed table { margin-bottom: 0; width: 100%; table-layout: fixed; }\n' +
                '.table-bordered { table-layout: fixed; width: 100%; }\n' +
                // 添加正式排课记录的绿色样式
                '.formal-schedule-row { background-color: #d4edda !important; color: #155724 !important; }\n' +
                '.formal-schedule-row td { border-color: #c3e6cb !important; }\n' +
                '</style>');
            $('head').append(style);

            // 添加空行切换按钮和最大化按钮
            var toggleButton = $("<button class='btn btn-xs btn-info toggle-empty-rows'>显示空行</button>");
            var maximizeButton = $("<button class='btn btn-xs btn-success' style='margin-left:5px;'></button>");
            //$(".table-responsive").before(toggleButton).before(maximizeButton);

            // 初始化表格变量
            var isTableMaximized = false;
            var $tableContainer = $(".table-responsive");
            var $originalTable = $('.table-bordered');
            var originalStyles = {};


            // 项目列表下拉框点击事件
            $(document).on('change', 'select#publicwelfare_id', function () {
                var id = $('select#publicwelfare_id option:selected').val();
                var name = $('select#publicwelfare_id option:selected').text();

                // 更新按钮文本
                $('.dropdown-toggle').html('<i class="fa fa-filter"></i> ' + name + ' <span class="caret"></span>');

                // 重新加载表格数据，带上项目ID参数

                if (id > 0) {
                    // 直接使用完整URL路径带参数
                    var url = 'course/schedule/index?publicwelfare_id=' + id;
                    var table = $("#table");
                    table.bootstrapTable('refresh', {
                        queryParams: function (params) {
                            params.publicwelfare_id = id;
                            return params;
                        }
                    });

                    // 异步加载社区和学科数据
                    loadCommunityAndSubject(id);
                } else {
                    // 如果是全部项目，使用原始 URL
                    thistable.bootstrapTable('refresh', {
                        url: $.fn.bootstrapTable.defaults.extend.index_url
                    });

                    // 清空社区和学科选择
                    $('#community_code_filter').html('<option value="0">全部社区</option>');
                    $('#subject_id_filter').html('<option value="0">全部学科</option>');
                }

                // 如果选择了具体项目，启用清空按钮
                if (id > 0) {
                    $('.btn-clear-schedule').removeClass('disabled').data('id', id);
                } else {
                    $('.btn-clear-schedule').addClass('disabled').data('id', 0);
                }
            });

            // 加载社区和学科数据的函数
            function loadCommunityAndSubject(projectId) {
                // 加载社区数据
                Fast.api.ajax({
                    url: 'course/schedule/getCommunityList',
                    data: {publicwelfare_id: projectId}
                }, function (data, ret) {
                    var options = '<option value="0">全部社区</option>';
                    $.each(data, function (key, value) {
                        options += '<option value="' + key + '">' + value + '</option>';
                    });
                    $('#community_code_filter').html(options);
                    return false;
                });

                // 加载学科数据
                // ✅ 推荐：使用 Fast.api.ajax（保持与框架一致）
                Fast.api.ajax({
                    url: 'course/schedule/getSubjectList',
                    data: {publicwelfare_id: projectId}
                }, function (data, ret) {
                    var options = '<option value="0">全部学科</option>';
                    $.each(data, function (key, value) {
                        options += '<option value="' + key + '">' + value + '</option>';
                    });
                    $('#subject_id_filter').html(options);
                    return false;
                });

            }

            // 清空项目排期按钮点击事件
            $(document).on('click', '.btn-clear-schedule:not(.disabled)', function () {
                var id = $(this).data('id');
                if (!id) {
                    Layer.alert('请先选择项目');
                    return;
                }

                Layer.confirm('确定要清空该项目的所有排期吗？此操作不可恢复！', {
                    icon: 3,
                    title: '警告'
                }, function (index) {
                    Fast.api.ajax({
                        url: 'course/schedule/clear',
                        data: {publicwelfare_id: id}
                    }, function (data, ret) {
                        // 清空成功后刷新表格
                        table.bootstrapTable('refresh');
                        return false;
                    });
                    Layer.close(index);
                });
            });

            // 保存原始样式
            function saveOriginalStyles() {
                originalStyles = {
                    width: $tableContainer.css('width'),
                    height: $tableContainer.css('height'),
                    position: $tableContainer.css('position'),
                    top: $tableContainer.css('top'),
                    left: $tableContainer.css('left'),
                    zIndex: $tableContainer.css('z-index'),
                    padding: $tableContainer.css('padding'),
                    overflow: $tableContainer.css('overflow'),
                    background: $tableContainer.css('background')
                };
            }

            saveOriginalStyles();

            // 初始化固定表头
            initFixedHeader();

            // 最大化表格功能
            maximizeButton.on('click', function () {
                if (!isTableMaximized) {
                    // 最大化表格
                    $tableContainer.css({
                        'position': 'fixed',
                        'top': '0',
                        'left': '0',
                        'width': '100%',
                        'height': '100%',
                        'background': '#fff',
                        'z-index': '9999',
                        'padding': '10px',
                        'overflow': 'auto'
                    });
                    $(this).text('还原表格');
                    isTableMaximized = true;

                    // 更新表头固定位置
                    setTimeout(updateColumnWidths, 100);
                } else {
                    // 还原表格
                    $tableContainer.css(originalStyles);
                    isTableMaximized = false;

                    // 更新表头固定位置
                    setTimeout(updateColumnWidths, 100);
                }
                return false;
            });

            // 时间段 - 检查并隐藏空行
            function checkEmptyRows() {
                // 首先标记所有行不是空的
                $('.table-bordered tr').removeClass('empty-row');

                // 检查每一行
                $('.table-bordered tr').each(function () {
                    var row = $(this);

                    // 跳过表头行
                    if (row.parents('thead').length > 0) {
                        return true;
                    }

                    // 计算该行中有课程的单元格数量
                    var emptyCells = 0;
                    var totalCells = 0;

                    // 查找课程内容单元格（跳过前两列：日期/时间 和 社区）
                    row.find('td:gt(1)').each(function () {
                        totalCells++;

                        // 如果单元格内容为空，增加空单元格计数
                        if ($(this).text().trim() === '') {
                            emptyCells++;
                        }
                    });

                    // 如果所有课程单元格都是空的，则标记为空行
                    if (totalCells > 0 && emptyCells === totalCells) {
                        row.addClass('empty-row');
                    }
                });

                // 更新跨行单元格 rowspan
                updateRowspans();
            }

            // 更新时间段合并行 - 根据行的分组计算rowspan
            function updateRowspans() {
                // 获取所有可见行
                var visibleRows = $('.table-striped tbody tr:visible, .table-bordered tbody tr:visible');
                var rowCount = visibleRows.length;

                // 找出所有带rowspan属性的单元格所在的行
                var rowsWithRowspan = [];
                visibleRows.each(function (index) {
                    var $row = $(this);
                    var $firstCell = $row.find('td:first-child');

                    // 检查首列是否带有rowspan属性
                    if ($firstCell.length > 0 && $firstCell.attr('rowspan')) {
                        rowsWithRowspan.push({
                            index: index,
                            row: $row,
                            cell: $firstCell
                        });
                    }
                });

                // 如果没有找到带rowspan的单元格，直接返回
                if (rowsWithRowspan.length === 0) return;

                // 计算每个带rowspan属性的单元格应该合并的行数
                for (var i = 0; i < rowsWithRowspan.length; i++) {
                    var currentRowInfo = rowsWithRowspan[i];
                    var nextRowInfo = rowsWithRowspan[i + 1];
                    var currentIndex = currentRowInfo.index;
                    var nextIndex = nextRowInfo ? nextRowInfo.index : rowCount;

                    // 计算从当前行到下一个带rowspan的行之间的可见行数
                    var rowsToMerge = nextIndex - currentIndex;

                    if (rowsToMerge > 1) {
                        // 设置rowspan值
                        currentRowInfo.cell.attr('rowspan', rowsToMerge);
                    } else {
                        // 如果没有行需要合并，则移除rowspan属性
                        currentRowInfo.cell.removeAttr('rowspan');
                    }
                }

                // 隐藏所有空的时间单元格
                visibleRows.each(function () {
                    var $firstCell = $(this).find('td:first-child');
                    if ($firstCell.text().trim() === '' && !$firstCell.attr('rowspan')) {
                        $firstCell.css('display', 'none');
                    }
                });
            }

            // 首次加载时检查并隐藏空行
            setTimeout(function () {
                checkEmptyRows();
            }, 500);

            // 初始化固定表头功能
            function initFixedHeader() {
                // 创建固定表头容器
                var $fixedHeader = $('<div>').addClass('table-header-fixed');
                var $cloneTable = $('<table>').addClass('table table-bordered');
                var $cloneThead = $originalTable.find('thead').clone();

                // 将克隆的表头添加到固定表头容器
                $cloneTable.append($cloneThead);
                $fixedHeader.append($cloneTable);
                $('body').append($fixedHeader);

                // 更新列宽和位置
                function updateColumnWidths() {
                    var columnWidths = [];
                    $originalTable.find('thead th').each(function (i) {
                        columnWidths[i] = $(this).outerWidth();
                    });

                    // 应用列宽到固定表头
                    $cloneTable.find('thead th').each(function (i) {
                        $(this).css('width', columnWidths[i] + 'px');
                    });

                    // 检查表格是否处于最大化状态
                    if (isTableMaximized) {
                        // 最大化状态下的固定表头位置
                        $fixedHeader.css({
                            'width': '100%',
                            'left': '0'
                        });
                    } else {
                        // 正常状态下的固定表头位置
                        $fixedHeader.css({
                            'width': $tableContainer.width() + 'px',
                            'left': $tableContainer.offset().left + 'px'
                        });
                    }

                    // 设置表格宽度
                    $cloneTable.css('width', $originalTable.outerWidth() + 'px');
                }

                // 绑定滚动事件
                $(window).on('scroll resize', function () {
                    var tableOffset = $originalTable.offset();
                    var tableTop = tableOffset.top;
                    var tableHeight = $originalTable.height();
                    var theadHeight = $cloneTable.find('thead').height();
                    var scrollTop = $(window).scrollTop();

                    if (scrollTop > tableTop && scrollTop < tableTop + tableHeight - theadHeight) {
                        $fixedHeader.css('display', 'block');
                        updateColumnWidths();
                    } else {
                        $fixedHeader.css('display', 'none');
                    }
                });

                // 全局引用，便于其他地方调用
                window.updateColumnWidths = updateColumnWidths;

                // 初始化时进行一次更新
                setTimeout(updateColumnWidths, 300);
            }

            // 当点击按钮时切换空行的显示/隐藏
            toggleButton.on('click', function () {
                $('.empty-row').toggle();
                var buttonText = $('.empty-row:visible').length > 0 ? '隐藏空行' : '显示空行';
                $(this).text(buttonText);

                // 重新计算rowspan
                updateRowspans();

                // 更新固定表头
                if (typeof window.updateColumnWidths === 'function') {
                    setTimeout(window.updateColumnWidths, 100);
                }

                return false; // 阻止默认行为
            });

            document.getElementById('exportBtn').addEventListener('click', function () {
                const exportBtn = document.getElementById('exportBtn');
                const statusDiv = document.getElementById('status');

                try {
                    // 获取表格元素
                    const table = document.getElementById('table');

                    // 创建工作簿
                    const wb = XLSX.utils.book_new();

                    // 创建数据矩阵和合并区域
                    const data = [];
                    const merges = [];
                    const allRows = table.rows;

                    // 过滤出可见的行（排除隐藏的行）
                    const visibleRows = [];
                    for (let r = 0; r < allRows.length; r++) {
                        const row = allRows[r];
                        // 检查行是否被隐藏（通过CSS类或style属性）
                        const isHidden = row.style.display === 'none' ||
                            row.classList.contains('empty-row') ||
                            $(row).hasClass('empty-row') ||
                            $(row).is(':hidden');

                        if (!isHidden) {
                            visibleRows.push(row);
                        }
                    }
                    // 计算实际需要的最大列数（基于可见行）
                    let maxCols = 0;
                    for (let r = 0; r < visibleRows.length; r++) {
                        let colCount = 0;
                        const cells = visibleRows[r].cells;
                        for (let c = 0; c < cells.length; c++) {
                            const cell = cells[c];
                            // 跳过隐藏的单元格
                            if (cell.style.display === 'none') {
                                continue;
                            }
                            const colSpan = cell.colSpan || 1;
                            colCount += colSpan;
                        }
                        maxCols = Math.max(maxCols, colCount);
                    }

                    // 获取选中的项目名称、社区名称、学科名称
                    const projectSelect = document.getElementById('publicwelfare_id');
                    const selectedProjectOption = projectSelect.options[projectSelect.selectedIndex];
                    const projectName = selectedProjectOption.text || '未选择项目';

                    const communitySelect = document.getElementById('community_code_filter');
                    const selectedCommunityOption = communitySelect.options[communitySelect.selectedIndex];
                    const communityName = selectedCommunityOption.text || '全部社区';

                    const subjectSelect = document.getElementById('subject_id_filter');
                    const selectedSubjectOption = subjectSelect.options[subjectSelect.selectedIndex];
                    const subjectName = selectedSubjectOption.text || '全部学科';

                    // 创建标题行
                    const titleText = `${projectName}${communityName}${subjectName}课程排课表`;

                    // 初始化数据矩阵（标题行 + 可见行数）
                    for (let r = 0; r <= visibleRows.length; r++) {
                        data[r] = new Array(maxCols).fill(null);
                    }

                    // 设置标题行
                    data[0][0] = titleText;
                    // 标题行合并所有列
                    if (maxCols > 1) {
                        merges.push({
                            s: {r: 0, c: 0},
                            e: {r: 0, c: maxCols - 1}
                        });
                    }

                    // 填充数据和处理合并区域（基于可见行，从第二行开始）
                    for (let r = 0; r < visibleRows.length; r++) {
                        const row = visibleRows[r];
                        const cells = row.cells;
                        let dataCol = 0; // 数据矩阵中的列索引
                        const dataRow = r + 1; // 在数据矩阵中的行索引（+1是因为第一行是标题）

                        for (let htmlCol = 0; htmlCol < cells.length; htmlCol++) {
                            const cell = cells[htmlCol];

                            // 跳过隐藏的单元格
                            if (cell.style.display === 'none') {
                                continue;
                            }

                            // 找到第一个可用的位置
                            while (dataCol < maxCols && data[dataRow][dataCol] !== null) {
                                dataCol++;
                            }

                            if (dataCol >= maxCols) break;

                            // 获取合并属性 - 使用DOM属性保持原有的rowspan值
                            const rowSpan = cell.rowSpan || 1;  // 保持原有的rowspan值
                            const colSpan = cell.colSpan || 1;

                            // 添加调试信息 - 输出第一个td的rowspan值
                            if (htmlCol === 0) {
                                console.log(`第${r + 1}行(可见行)，第1列的rowspan值: ${rowSpan}`);
                                console.log(`该单元格内容: "${cell.textContent.trim()}"`);
                            }

                            // 设置主单元格的值
                            const cellValue = cell.textContent.trim();
                            data[dataRow][dataCol] = cellValue;

                            // 处理合并区域 - 使用原有的rowspan值
                            if (rowSpan > 1 || colSpan > 1) {
                                // 计算在可见行中的实际结束行（+1是因为标题行）
                                let actualEndRow = Math.min(dataRow + rowSpan - 1, visibleRows.length);

                                // 添加合并区域定义
                                merges.push({
                                    s: {r: dataRow, c: dataCol}, // 起始位置
                                    e: {r: actualEndRow, c: dataCol + colSpan - 1} // 结束位置
                                });

                                // 在数据矩阵中标记被合并的单元格区域
                                for (let i = 0; i <= actualEndRow - dataRow; i++) {
                                    for (let j = 0; j < colSpan; j++) {
                                        if (dataRow + i < data.length && dataCol + j < maxCols) {
                                            if (i === 0 && j === 0) {
                                                // 主单元格保持原值
                                                continue;
                                            }
                                            // 被合并的单元格设置为undefined
                                            data[dataRow + i][dataCol + j] = undefined;
                                        }
                                    }
                                }
                            }

                            dataCol += colSpan;
                        }
                    }

                    // 清理数据矩阵，移除末尾的null值
                    const cleanedData = data.map(row => {
                        let lastIndex = row.length - 1;
                        while (lastIndex >= 0 && (row[lastIndex] === null || row[lastIndex] === undefined)) {
                            lastIndex--;
                        }
                        return row.slice(0, lastIndex + 1);
                    });

                    // 创建工作表
                    const ws = XLSX.utils.aoa_to_sheet(cleanedData);

                    // 设置合并区域
                    if (merges.length > 0) {
                        ws['!merges'] = merges;
                    }

                    // 设置列宽自适应
                    const colWidths = [];
                    for (let c = 0; c < maxCols; c++) {
                        let maxWidth = 8; // 最小宽度
                        for (let r = 0; r < cleanedData.length; r++) {
                            if (cleanedData[r][c] !== null && cleanedData[r][c] !== undefined) {
                                const cellValue = String(cleanedData[r][c]).trim(); // 去除两端空格
                                // 计算字符宽度（中文字符按2个字符宽度计算）
                                let width = 0;
                                for (let i = 0; i < cellValue.length; i++) {
                                    if (cellValue.charCodeAt(i) > 255) {
                                        width += 2; // 中文字符
                                    } else {
                                        width += 1; // 英文字符
                                    }
                                }
                                maxWidth = Math.max(maxWidth, width + 1); // 加1个字符的边距
                            }
                        }
                        colWidths.push({wch: Math.min(maxWidth, 40)}); // 最大宽度限制为40
                    }
                    ws['!cols'] = colWidths;

                    // 设置单元格样式
                    const range = XLSX.utils.decode_range(ws['!ref']);
                    for (let R = range.s.r; R <= range.e.r; ++R) {
                        for (let C = range.s.c; C <= range.e.c; ++C) {
                            const cellAddress = XLSX.utils.encode_cell({r: R, c: C});
                            if (!ws[cellAddress]) {
                                // 如果单元格不存在，创建一个空单元格
                                ws[cellAddress] = {t: 's', v: ''};
                            }

                            // 初始化样式对象
                            if (!ws[cellAddress].s) ws[cellAddress].s = {};

                            // 设置基础边框（所有单元格都有边框）
                            ws[cellAddress].s.border = {
                                top: {style: 'thin', color: {rgb: '000000'}},
                                bottom: {style: 'thin', color: {rgb: '000000'}},
                                left: {style: 'thin', color: {rgb: '000000'}},
                                right: {style: 'thin', color: {rgb: '000000'}}
                            };

                            // 第一行标题样式
                            if (R === 0) {
                                ws[cellAddress].s.font = {
                                    name: '黑体',
                                    bold: true,
                                    sz: 14
                                };
                                ws[cellAddress].s.alignment = {
                                    horizontal: 'center',
                                    vertical: 'center'
                                };
                                // 标题行外边框加粗
                                ws[cellAddress].s.border = {
                                    top: {style: 'thick', color: {rgb: '000000'}},
                                    bottom: {style: 'thick', color: {rgb: '000000'}},
                                    left: {style: 'thick', color: {rgb: '000000'}},
                                    right: {style: 'thick', color: {rgb: '000000'}}
                                };
                            }
                            // 表头样式（第二行）
                            else if (R === 1) {
                                ws[cellAddress].s.font = {
                                    name: '黑体',
                                    bold: true,
                                    sz: 11
                                };
                                ws[cellAddress].s.alignment = {
                                    horizontal: 'center',
                                    vertical: 'center'
                                };
                                // 表头边框
                                ws[cellAddress].s.border = {
                                    top: {style: 'thick', color: {rgb: '000000'}},
                                    bottom: {style: 'thin', color: {rgb: '000000'}},
                                    left: {style: 'thick', color: {rgb: '000000'}},
                                    right: {style: 'thick', color: {rgb: '000000'}}
                                };
                            }
                            // 内容样式
                            else {
                                ws[cellAddress].s.font = {
                                    name: '宋体',
                                    bold: false,
                                    sz: 10
                                };
                                ws[cellAddress].s.alignment = {
                                    horizontal: 'center',
                                    vertical: 'center'
                                };
                            }

                            // 最后一行底边框加粗
                            if (R === range.e.r) {
                                ws[cellAddress].s.border.bottom = {style: 'thick', color: {rgb: '000000'}};
                            }

                            // 最左列和最右列边框加粗
                            if (C === range.s.c) {
                                ws[cellAddress].s.border.left = {style: 'thick', color: {rgb: '000000'}};
                            }
                            if (C === range.e.c) {
                                ws[cellAddress].s.border.right = {style: 'thick', color: {rgb: '000000'}};
                            }
                        }
                    }

                    // 添加工作表到工作簿
                    const sheetName = 'Sheet1';
                    XLSX.utils.book_append_sheet(wb, ws, sheetName);

                    // 生成Excel文件并下载
                    const fileName = `排课表_${projectName}_${communityName}_${subjectName}_${new Date().getFullYear()}年${new Date().getMonth() + 1}月`;
                    const fileType = 'xlsx';
                    XLSX.writeFile(wb, `${fileName}.${fileType}`);

                    // 显示成功状态
                    if (statusDiv) {
                        statusDiv.textContent = `导出成功！文件名: ${fileName}.${fileType}`;
                    }

                } catch (error) {
                    if (statusDiv) {
                        statusDiv.textContent = '导出失败: ' + error.message;
                        statusDiv.className = 'status error';
                    }
                }
            });


        },
        generate: function () {

            $(document).on("click", "#btn-generate", function () {
                var projectId = $("#publicwelfare_id").val();
                var projectTitle = $("#publicwelfare_title").val();
                var communityId = $("#community_id").val();
                var communityTitle = $("#community_title").val();
                var subjectId = $("#subject_id").val();
                var subjectTitle = $("#subject_title").val();
                var year = $("#year").val();
                var month = $("#month").val();
                var statusDiv = document.getElementById('status');
                Controller.api.generateExcel(projectId, projectTitle, communityId, communityTitle, subjectId, subjectTitle, year, month, statusDiv);
                return false;
            });
        },
        api: {
            bindevent: function () {
                Form.api.bindevent($("form[role=form]"));
            },
            generateExcel: function (projectId, projectTitle, communityId, communityTitle, subjectId, subjectTitle, year, month, statusDiv) {
                $.ajax({
                    url: 'schedule/generate',
                    type: 'POST',
                    data: {
                        publicwelfare_id: projectId,
                        projectTitle: projectTitle,
                        communityId: communityId,
                        communityTitle: communityTitle,
                        subjectId: subjectId,
                        subjectTitle: subjectTitle,
                        year: year,
                        month: month
                    },
                    success: function (response) {
                        if (response.code === 1) {
                            if (statusDiv) {
                                statusDiv.textContent = response.msg;
                                statusDiv.className = 'status success';

                            }
                        }
                    }
                });
            }
        }
    };

    // 添加排课事件分组处理函数
    // 此函数已在上方定义，这里移除重复定义
    // function handleScheduleEventGrouping() {
    //     // 初始化全局变量
    //     window.scheduleExpiredRecords = [];
    //     window.scheduleNormalRecords = [];
    //     window.scheduleCurrentPage = {
    //         expired: 1,
    //         normal: 1
    //     };
    //     window.schedulePageSize = 30;
    //     
    //     // 获取当前日期字符串
    //     var today = new Date();
    //     var currentDateStr = today.getFullYear() + '-' + 
    //                         String(today.getMonth() + 1).padStart(2, '0') + '-' + 
    //                         String(today.getDate()).padStart(2, '0');
    //     
    //     console.log('=== 排课事件分组调试 ===');
    //     console.log('当前日期:', currentDateStr);
    //     
    //     var totalRows = $('#table tbody tr').length;
    //     var processedRows = 0;
    //     var expiredCount = 0;
    //     var normalCount = 0;
    //     var emptyDateCount = 0;
    //     var invalidDateCount = 0;
    //     
    //     console.log('总行数:', totalRows);
    //     
    //     // 遍历表格行，分组过期和未过期的事件
    //     $('#table tbody tr').each(function(index) {
    //         var $row = $(this);
    //         processedRows++;
    //         
    //         // 检查行的基本信息
    //         var rowId = $row.find('td').eq(1).text().trim(); // ID列
    //         var timeSlotCell = $row.find('td').eq(8); // 时间列（第9列）
    //         var timeSlotText = timeSlotCell.text().trim();
    //         
    //         console.log('处理第', index + 1, '行, ID:', rowId, '时间文本:', timeSlotText);
    //         
    //         if (timeSlotText && timeSlotText !== '') {
    //             // 从时间字符串中提取日期部分（格式如"2025-07-10 15:15-16:45"）
    //             var dateMatch = timeSlotText.match(/(\d{4}-\d{1,2}-\d{1,2})/);
    //             if (dateMatch) {
    //                 var dateOnly = dateMatch[1];
    //                 
    //                 // 标准化日期格式
    //                 var dateParts = dateOnly.split('-');
    //                 var standardDate = dateParts[0] + '-' + 
    //                                  String(parseInt(dateParts[1])).padStart(2, '0') + '-' + 
    //                                  String(parseInt(dateParts[2])).padStart(2, '0');
    //                 
    //                 console.log('提取的日期:', dateOnly, '标准化后:', standardDate);
    //                 
    //                 // 比较日期字符串
    //                 if (standardDate < currentDateStr) {
    //                     console.log('已过期事件:', standardDate);
    //                     window.scheduleExpiredRecords.push($row.clone(true));
    //                     $row.addClass('expired-original').hide();
    //                     expiredCount++;
    //                 } else {
    //                     console.log('未过期事件:', standardDate);
    //                     window.scheduleNormalRecords.push($row.clone(true));
    //                     $row.addClass('normal-original');
    //                     normalCount++;
    //                 }
    //             } else {
    //                 console.log('无效日期格式:', timeSlotText);
    //                 invalidDateCount++;
    //                 window.scheduleNormalRecords.push($row.clone(true));
    //                 $row.addClass('normal-original');
    //                 normalCount++;
    //             }
    //         } else {
    //             console.log('空日期，归类为未过期');
    //             window.scheduleNormalRecords.push($row.clone(true));
    //             $row.addClass('normal-original');
    //             emptyDateCount++;
    //             normalCount++;
    //         }
    //     });
    //     
    //     // 输出统计信息
    //     console.log('=== 排课分组统计 ===');
    //     console.log('总行数:', totalRows);
    //     console.log('处理行数:', processedRows);
    //     console.log('表格数据:', $('#table').bootstrapTable('getData'));
    //     console.log('表格选项:', $('#table').bootstrapTable('getOptions'));
    //     console.log('已过期事件数:', expiredCount);
    //     console.log('未过期事件数:', normalCount);
    //     console.log('空日期数:', emptyDateCount);
    //     console.log('无效日期数:', invalidDateCount);
    //     console.log('已过期数组长度:', window.scheduleExpiredRecords.length);
    //     console.log('未过期数组长度:', window.scheduleNormalRecords.length);
    //     console.log('总计:', window.scheduleExpiredRecords.length + window.scheduleNormalRecords.length);
    //     
    //     // 检查数据完整性
    //     if (totalRows !== (window.scheduleExpiredRecords.length + window.scheduleNormalRecords.length)) {
    //         console.error('❌ 数据丢失！总行数与分组后数量不匹配');
    //         console.error('总行数:', totalRows);
    //         console.error('分组后总数:', window.scheduleExpiredRecords.length + window.scheduleNormalRecords.length);
    //         console.error('差异:', totalRows - (window.scheduleExpiredRecords.length + window.scheduleNormalRecords.length));
    //     } else {
    //         console.log('✅ 数据完整性检查通过');
    //     }
    //     
    //     // 创建切换控制器
    //     createScheduleEventToggleController();
    // }

    // 创建排课事件切换控制器
    function createScheduleEventToggleController() {
        // 移除现有的控制器
        $('#schedule-event-toggle-controller').remove();

        // 创建切换按钮容器和分页控制器
        var controllerHtml = '<div id="schedule-event-toggle-controller" style="margin-bottom: 15px; padding: 10px; background-color: #f8f9fa; border-radius: 5px; border: 1px solid #dee2e6;">' +
            '<div class="row">' +
            '<div class="col-md-6">' +
            '<div class="btn-group" role="group">' +
            '<button type="button" class="btn btn-primary btn-sm toggle-schedule-normal active" data-type="normal">' +
            '<i class="fa fa-calendar-check-o"></i> 未过期事件 (' + window.scheduleNormalRecords.length + ')' +
            '</button>' +
            '<button type="button" class="btn btn-outline-secondary btn-sm toggle-schedule-expired" data-type="expired">' +
            '<i class="fa fa-clock-o"></i> 已过期事件 (' + window.scheduleExpiredRecords.length + ')' +
            '</button>' +
            '</div>' +
            '</div>' +
            '<div class="col-md-6 text-right">' +
            '<div id="schedule-pagination-info" class="d-inline-block mr-3"></div>' +
            '<div id="schedule-pagination-controls" class="d-inline-block"></div>' +
            '</div>' +
            '</div>' +
            '</div>';

        // 将控制器插入到表格前面
        $('#table').before(controllerHtml);

        // 创建底部分页控制器
        createScheduleBottomPaginationController();

        // 默认显示未过期事件
        window.scheduleCurrentView = 'normal';
        showScheduleEventsByType('normal');

        // 绑定切换事件
        $('.toggle-schedule-normal, .toggle-schedule-expired').off('click').on('click', function () {
            var type = $(this).data('type');

            // 更新按钮状态
            $('.toggle-schedule-normal, .toggle-schedule-expired').removeClass('btn-primary active').addClass('btn-outline-secondary');
            $(this).removeClass('btn-outline-secondary').addClass('btn-primary active');

            // 切换显示内容
            window.scheduleCurrentView = type;
            showScheduleEventsByType(type);
        });
    }

    // 创建排课底部分页控制器
    function createScheduleBottomPaginationController() {
        // 移除现有的底部控制器
        $('#schedule-bottom-pagination-controller').remove();

        // 创建底部分页控制器HTML
        var bottomControllerHtml = '<div id="schedule-bottom-pagination-controller" style="margin-top: 15px; padding: 15px; background-color: #f8f9fa; border-radius: 5px; border: 1px solid #dee2e6; border-top: 2px solid #007bff;">' +
            '<div class="row align-items-center">' +
            '<div class="col-md-6">' +
            '<div id="schedule-bottom-pagination-info" class="text-muted"></div>' +
            '</div>' +
            '<div class="col-md-6">' +
            '<div id="schedule-bottom-pagination-controls" class="text-right"></div>' +
            '</div>' +
            '</div>' +
            '</div>';

        // 将底部控制器插入到表格后面
        $('#table').after(bottomControllerHtml);
    }

    // 根据类型显示排课事件（带分页）
    function showScheduleEventsByType(type) {
        // 清空当前表格内容
        $('#table tbody').empty();

        var allRows = type === 'expired' ? window.scheduleExpiredRecords : window.scheduleNormalRecords;
        var currentPage = window.scheduleCurrentPage[type];
        var pageSize = window.schedulePageSize;

        if (allRows.length === 0) {
            // 如果没有数据，显示提示信息
            var emptyMessage = type === 'expired' ? '暂无已过期的排课记录' : '暂无未过期的排课记录';
            $('#table tbody').append(
                '<tr><td colspan="100%" class="text-center text-muted" style="padding: 40px;">' +
                '<i class="fa fa-' + (type === 'expired' ? 'clock-o' : 'calendar-check-o') + ' fa-2x"></i><br>' +
                '<div class="mt-2">' + emptyMessage + '</div>' +
                '</td></tr>'
            );
            // 隐藏分页控制器
            $('#schedule-pagination-info').empty();
            $('#schedule-pagination-controls').empty();
            $('#schedule-bottom-pagination-info').empty();
            $('#schedule-bottom-pagination-controls').empty();
        } else {
            // 计算分页参数
            var totalPages = Math.ceil(allRows.length / pageSize);
            var startIndex = (currentPage - 1) * pageSize;
            var endIndex = Math.min(startIndex + pageSize, allRows.length);
            var rowsToShow = allRows.slice(startIndex, endIndex);

            // 添加对应类型的行
            rowsToShow.forEach(function ($row) {
                var $newRow = $row.clone(true);

                // 为过期行添加特殊样式
                if (type === 'expired') {
                    $newRow.addClass('expired-schedule-row');
                }

                $('#table tbody').append($newRow);
            });

            // 更新分页信息
            updateSchedulePaginationInfo(type, currentPage, totalPages, startIndex + 1, endIndex, allRows.length);

            // 更新分页控制器
            updateSchedulePaginationControls(type, currentPage, totalPages);
        }

        // 添加样式 - 更新时间: 2024-12-23
        if (!$('#schedule-event-grouping-styles').length) {
            $('<style id="schedule-event-grouping-styles">' +
                '.expired-schedule-row { background-color: #fff5f5 !important; }' +
                '.expired-schedule-row td { border: none !important; color: #721c24; font-weight: normal !important; }' +
                '.expired-schedule-row { border: none !important; }' +
                '.toggle-schedule-normal.active, .toggle-schedule-expired.active { box-shadow: 0 2px 4px rgba(0,123,255,0.3); }' +
                '#schedule-event-toggle-controller .btn { transition: all 0.2s ease; }' +
                '#schedule-event-toggle-controller .btn:hover { transform: translateY(-1px); }' +
                '.schedule-pagination-btn { margin: 0 2px; padding: 4px 8px; border: 1px solid #ddd; background: #fff; cursor: pointer; }' +
                '.schedule-pagination-btn:hover { background: #f5f5f5; }' +
                '.schedule-pagination-btn.active { background: #007bff; color: #fff; border-color: #007bff; }' +
                '.schedule-pagination-btn:disabled { background: #f8f9fa; color: #6c757d; cursor: not-allowed; }' +
                // 添加正式排课记录的绿色样式
                '.formal-schedule-row { background-color: #d4edda !important; color: #155724 !important; }\n' +
                '.formal-schedule-row td { border-color: #c3e6cb !important; }\n' +
                '</style>').appendTo('head');
        }
    }

    // 更新排课分页信息
    function updateSchedulePaginationInfo(type, currentPage, totalPages, startIndex, endIndex, totalRecords) {
        var typeText = type === 'expired' ? '已过期' : '未过期';
        var infoText = '显示 ' + typeText + ' 第 ' + startIndex + '-' + endIndex + ' 条，共 ' + totalRecords + ' 条记录（第 ' + currentPage + '/' + totalPages + ' 页）';

        // 同时更新顶部和底部的分页信息
        $('#schedule-pagination-info').html('<small class="text-muted">' + infoText + '</small>');
        $('#schedule-bottom-pagination-info').html('<div class="d-flex align-items-center">' +
            '<i class="fa fa-info-circle text-primary mr-2"></i>' +
            '<span>' + infoText + '</span>' +
            '</div>');
    }

    // 更新排课分页控制器
    function updateSchedulePaginationControls(type, currentPage, totalPages) {
        var controlsHtml = '';

        if (totalPages > 1) {
            // 上一页按钮
            controlsHtml += '<button class="schedule-pagination-btn" data-page="' + (currentPage - 1) + '" data-type="' + type + '"' +
                (currentPage <= 1 ? ' disabled' : '') + '>上一页</button>';

            // 页码按钮
            var startPage = Math.max(1, currentPage - 2);
            var endPage = Math.min(totalPages, currentPage + 2);

            if (startPage > 1) {
                controlsHtml += '<button class="schedule-pagination-btn" data-page="1" data-type="' + type + '">1</button>';
                if (startPage > 2) {
                    controlsHtml += '<span class="pagination-ellipsis">...</span>';
                }
            }

            for (var i = startPage; i <= endPage; i++) {
                controlsHtml += '<button class="schedule-pagination-btn' + (i === currentPage ? ' active' : '') + '" data-page="' + i + '" data-type="' + type + '">' + i + '</button>';
            }

            if (endPage < totalPages) {
                if (endPage < totalPages - 1) {
                    controlsHtml += '<span class="pagination-ellipsis">...</span>';
                }
                controlsHtml += '<button class="schedule-pagination-btn" data-page="' + totalPages + '" data-type="' + type + '">' + totalPages + '</button>';
            }

            // 下一页按钮
            controlsHtml += '<button class="schedule-pagination-btn" data-page="' + (currentPage + 1) + '" data-type="' + type + '"' +
                (currentPage >= totalPages ? ' disabled' : '') + '>下一页</button>';
        }

        // 同时更新顶部和底部的分页控制器
        $('#schedule-pagination-controls').html(controlsHtml);
        $('#schedule-bottom-pagination-controls').html(controlsHtml);

        // 绑定分页按钮事件（顶部和底部）
        $('.schedule-pagination-btn').off('click').on('click', function () {
            if ($(this).prop('disabled')) return;

            var page = parseInt($(this).data('page'));
            var pageType = $(this).data('type');

            if (page > 0 && page <= totalPages) {
                window.scheduleCurrentPage[pageType] = page;
                showScheduleEventsByType(pageType);
            }
        });
    }

    return Controller;
});